Why modify the input array? Yes, is a peeve of mine :) We are not adding value, i.e. sorting, so this code is destructive. Passing in the same array twice could yield different results (i.e. non-deterministic).

Instead, try something like this:

public bool CheckPossibility(int[] nums) {
    int badIdx = -1;
    for (int i = 0; i < nums.Length - 1; i++) {
        if (nums[i] > nums[i + 1]) {
            if (badIdx == -1) {
                badIdx = i;
            }
            else {
                return false;
            }
        }
    }
    if (badIdx <= 0 || badIdx == nums.Length - 2) {
        return true;
    }
    else {
        return nums[badIdx - 1] <= nums[badIdx + 1] || nums[badIdx] <= nums[badIdx + 2];
    }
}

Hi, dudes! How's tricks?

class Solution {
    func checkPossibility(_ nums: [Int]) -> Bool {
        guard nums.count > 2 else { return true }
        var modify = 0, n = nums.count - 1
        while n != 0 {
            if nums[n] < nums[n-1] {
                modify += 1
                if n > 1,
                   n < nums.count - 1,
                   nums[n+1] < nums[n-1],
                   nums[n-2] > nums[n] { return false }
            }
            if modify > 1 { return false }
            n -= 1
        }
        return true
    }
}

import XCTest

// Executed 2 tests, with 0 failures (0 unexpected) in 0.004 (0.006) seconds

class Tests: XCTestCase {
    private let s = Solution()
    func testExample1() {
        XCTAssertTrue(s.checkPossibility([4,2,3])) // success
    }
    func testExample2() {
        XCTAssertFalse(s.checkPossibility([4,2,1])) // success
    }
}

Tests.defaultTestSuite.run()

This solution is simple and easy to understand with visualized diagrams. Just one more thing to consider is that it's always better solution not to modify input.

here is my solution not to modify input. It just checks whether it's possible to make local non decreasing state and then if it is not possible, just return false.

class Solution {
public:
    bool checkPossibility(vector<int>& nums) {
        int len = nums.size();
        bool modified = false;
        for (int i=0; i < len-1; i++) {
            if (nums[i] > nums[i+1]) {
                if (modified) {
                    return false;
                }
                if (i-1 < 0 || nums[i-1] <= nums[i+1]) {
                    // in this case, you can change nums[i] = x (nums[i-1] <= x <= nums[i+1])
                } else if (i + 2 >= len || nums[i] <= nums[i+2]) {
                    // in this case, you can change nums[i+1] = x (nums[i] <= x <= nums[i+2])
                } else {
                    // if it's not the both of them, it's not possible to make sorted state with one modification
                    return false;
                }
                modified = true;
            }
        }
        return true;
    }
};

Follow up: what if you can change at most k elements?

Another way to look at this is this, if the longest increasing subsequence is greater than equal to n-1, then return true, else return false, O(nlogn) though, just hit me hence tried, passing all test cases, though obviously the solution approach is better.

Wow, this question was trickier than i thought at the beginning.

This is medium? I have been staring into space with this problem :(

How would you rate this? Pop the bad one and see if it's sorted.

class Solution:
    def checkPossibility(self, nums: List[int]) -> bool:
        if all(nums[i] <= nums[i+1] for i in range(len(nums)-1)):
            return True
        for i in range(0,len(nums)):
            o = list(nums)
            o.pop(i)
            if all(o[x] <= o[x+1] for x in range(len(o)-1)):
                return True
        return False

We can insert a minimum value to remove i < 2 check in if i < 2 or nums[i - 2] <= nums[i]:, here is the code in Python3,

class Solution:
    def checkPossibility(self, nums: List[int]) -> bool:
        nums.insert(0, -10**5)
        hit = False
        for i in range(2, len(nums)):
            if nums[i-1] > nums[i]:
                if hit:
                    return False
                hit = True
                
                if nums[i-2] > nums[i]:
                    nums[i] = nums[i-1]
                else:
                    nums[i-1] = nums[i-2]
        return True

Here is a straightforward approach O(n) using stack.

bool checkPossibility(vector<int>& nums) {
        stack<int> stk;
        bool modified=false;
        stk.push(INT_MIN); // if any changes at num[0] are required
        stk.push(nums[0]);
        for (int i=1; i<nums.size(); i++){
            if (nums[i]>=nums[i-1]){
				stk.push(nums[i]); 
				 }
            else{
                if (modified) return false;// already modified a value?
                modified=true;
                //either (a) make num[i] to be equal to nums[i-1]
                //or (b) make the num[i-1] to be the least possible value possible for it
				// we could only do one of the above to make the array right
                int last=stk.top();
                stk.pop();
                int largestOnStack=stk.top();
                if (largestOnStack>nums[i]){nums[i]= last;} // [... 4, 5, 3, ...] we will have to modify 3 to 5
                else
                    last= largestOnStack; // [...3, 5, 4...] we can change 5 to 4 and the array would still be valid!
                stk.push(last);
                stk.push(nums[i]);
            }
        }
        return true;
    }